home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1996 June / EnigmA AMIGA RUN 08 (1996)(G.R. Edizioni)(IT)[!][issue 1996-06][EARSAN CD VII].iso / earcd / comm1 / s2mtr376.lha / SANA2Meter / Source / gui.c < prev    next >
C/C++ Source or Header  |  1996-04-26  |  17KB  |  563 lines
  1. /*
  2. ** $VER: gui.c 1.0 (25 Apr 1996)
  3. **
  4. ** (C) Copyright 1996 Marius Gröger
  5. **     All Rights Reserved
  6. **
  7. ** $HISTORY:
  8. **
  9. ** 25 Apr 1996 : 001.000 :  created
  10. */
  11.  
  12. #define DEBUG 0
  13.  
  14. /*F*/ /* includes */
  15.  
  16. #include <clib/alib_protos.h>
  17. #include <clib/utility_protos.h>
  18. #include <pragmas/utility_pragmas.h>
  19. #include <clib/exec_protos.h>
  20. #include <pragmas/exec_sysbase_pragmas.h>
  21. #include <clib/dos_protos.h>
  22. #include <pragmas/dos_pragmas.h>
  23. #include <clib/intuition_protos.h>
  24. #include <pragmas/intuition_pragmas.h>
  25. #include <clib/gadtools_protos.h>
  26. #include <pragmas/gadtools_pragmas.h>
  27. #include <clib/icon_protos.h>
  28. #include <pragmas/icon_pragmas.h>
  29. #include <clib/locale_protos.h>
  30. #include <pragmas/locale_pragmas.h>
  31. #include <gtlayout/gtlayout.h>
  32. #include <exec/libraries.h>
  33. #include <exec/devices.h>
  34. #include <exec/memory.h>
  35. #include <exec/io.h>
  36. #include <workbench/startup.h>
  37. #include <utility/tagitem.h>
  38. #define AsmPools
  39. #include <pools/pool_lib.h>
  40.  
  41. #if (USE_EXTREADARGS != 0)
  42. #include <extrdargs.h>
  43. #endif
  44.  
  45. #include "compiler.h"
  46. #include "debug.h"
  47. #define CATCOMP_NUMBERS
  48. #include "locale.h"
  49. #include "sana2meter.h"
  50. #include "constdata.h"
  51.  
  52. #include <strings.h>
  53. #include <stddef.h>
  54. /*E*/
  55.  
  56. /*F*/ /* private symbols */
  57. /*E*/
  58. /*F*/ /* exported symbols */
  59. PUBLIC BOOL preparemenu(GD gd);
  60. PUBLIC VOID checkmenu(GD gd);
  61. PUBLIC VOID updategui(GD gd, BOOL complete);
  62. PUBLIC VOID closegui(GD gd);
  63. PUBLIC BOOL opengui(GD gd);
  64. PUBLIC BOOL dowindow(GD gd, BOOL *update);
  65. /*E*/
  66. /*F*/ /* imported symbols */
  67. IMPORT STDARGS STRPTR GetString(struct LocaleInfo *li, LONG stringNum);
  68. IMPORT VOID saveconfig(GD gd);
  69. IMPORT VOID message(GD gd, LONG title, LONG body, LONG button, ...);
  70. IMPORT VOID *allocpvec(GD gd, ULONG len);
  71. IMPORT VOID freepvec(GD gd, VOID *mem);
  72. IMPORT VOID *allocppvec(GD gd, ULONG len);
  73. IMPORT VOID freeppvec(GD gd, VOID *mem);
  74. /*E*/
  75.  
  76. /*F*/ /* intervals */
  77. PUBLIC const ULONG intervals[] =
  78. {
  79.    {  1 },
  80.    {  2 },
  81.    {  3 },
  82.    {  4 },
  83.    {  5 },
  84.    { 10 },
  85.    { 20 },
  86.    { 30 },
  87.    { 40 },
  88.    { 50 },
  89.    { 60 }
  90. };
  91. /*E*/
  92. /*F*/ /* menu data structures */
  93. PRIVATE const struct NewMenu menu[] =
  94. {
  95.    NM_TITLE, (STRPTR)MENU_PROJECT,          NULL, 0,                      0, NULL,
  96.    NM_ITEM,  (STRPTR)MENU_SAVECONFIG,       NULL, 0,                      0, NULL,
  97.    NM_ITEM,  (STRPTR)NM_BARLABEL,           NULL, 0,                      0, NULL,
  98.    NM_ITEM,  (STRPTR)MENU_ABOUT,            NULL, 0,                      0, NULL,
  99.    NM_ITEM,  (STRPTR)NM_BARLABEL,           NULL, 0,                      0, NULL,
  100.    NM_ITEM,  (STRPTR)MENU_QUIT,             NULL, 0,                      0, NULL,
  101.    NM_TITLE, (STRPTR)MENU_SETTINGS,         NULL, 0,                      0, NULL,
  102.    NM_ITEM,  (STRPTR)MENU_UPDATE,           NULL, 0,                      0, NULL,
  103.    NM_SUB,   (STRPTR)MENU_REFRESH1,         NULL, CHECKIT,               ~1, NULL,
  104.    NM_SUB,   (STRPTR)MENU_REFRESH2,         NULL, CHECKIT,               ~2, NULL,
  105.    NM_SUB,   (STRPTR)MENU_REFRESH3,         NULL, CHECKIT,               ~4, NULL,
  106.    NM_SUB,   (STRPTR)MENU_REFRESH4,         NULL, CHECKIT,               ~8, NULL,
  107.    NM_SUB,   (STRPTR)MENU_REFRESH5,         NULL, CHECKIT,              ~16, NULL,
  108.    NM_SUB,   (STRPTR)MENU_REFRESH10,        NULL, CHECKIT,              ~32, NULL,
  109.    NM_SUB,   (STRPTR)MENU_REFRESH20,        NULL, CHECKIT,              ~64, NULL,
  110.    NM_SUB,   (STRPTR)MENU_REFRESH30,        NULL, CHECKIT,             ~128, NULL,
  111.    NM_SUB,   (STRPTR)MENU_REFRESH40,        NULL, CHECKIT,             ~256, NULL,
  112.    NM_SUB,   (STRPTR)MENU_REFRESH50,        NULL, CHECKIT,             ~512, NULL,
  113.    NM_SUB,   (STRPTR)MENU_REFRESH60,        NULL, CHECKIT,            ~1024, NULL,
  114.    NM_ITEM,  (STRPTR)NM_BARLABEL,           NULL, 0,                      0, NULL,
  115.    NM_END
  116. };
  117.  
  118. #define FIRST_REFRESH_ITEM 8
  119.  
  120. #define FIRST_WATCH_ITEM  20
  121.  
  122. /*E*/
  123.  
  124. /*F*/ PUBLIC BOOL dowindow(GD gd, BOOL *update)
  125. {
  126.    struct IntuiMessage *im;
  127.    ULONG qualifier;
  128.    ULONG class;
  129.    UWORD code;
  130.    struct Gadget *gadget;
  131.    BOOL running = TRUE;
  132.    PD pd = gd->gd_Public;
  133.  
  134.    while(im = GT_GetIMsg(gd->gd_Handle->Window->UserPort))
  135.    {
  136.       class     = im->Class;
  137.       code      = im->Code;
  138.       qualifier = im->Qualifier;
  139.       gadget    = im->IAddress;
  140.  
  141.       GT_ReplyIMsg(im);
  142.  
  143.       LT_HandleInput(gd->gd_Handle, qualifier, &class, &code, &gadget);
  144.  
  145.       switch(class)
  146.       {
  147.          case IDCMP_CLOSEWINDOW:
  148.              running = FALSE;
  149.          break;
  150.  
  151.          case IDCMP_MENUPICK:
  152.          {
  153.             UWORD n_menu, n_item, n_subitem;
  154.             struct MenuItem *it;
  155.  
  156.             while(it = ItemAddress(gd->gd_Menu, code))
  157.             {
  158.                n_menu = MENUNUM(code);
  159.                n_item = ITEMNUM(code);
  160.                n_subitem = SUBNUM(code);
  161.  
  162.                if (n_menu == 0)
  163.                {
  164.                   if (n_item == 0)
  165.                      saveconfig(gd);
  166.  
  167.                   if (n_item == 2)
  168.                   {
  169.                      message(gd, REQ_ABOUT_TITLE, REQ_ABOUT_BODY, REQ_ABOUT_BUTTON,
  170.                         VERSION, REVISION, EMAIL_AUTHOR);
  171.                   }
  172.  
  173.                   if (n_item == 4)
  174.                      running = FALSE;
  175.                }
  176.                else if (n_menu == 1)
  177.                {
  178.                   if (n_item == 0)
  179.                   {
  180.                      gd->gd_time.tv_secs = intervals[n_subitem];
  181.                      AbortIO((struct IORequest*)&pd->pd_TReq);
  182.                   }
  183.                   if (n_item >= 2)
  184.                   {
  185.                      struct GlobalDevData *gdd;
  186.  
  187.                      if (gdd = (struct GlobalDevData *)GTMENUITEM_USERDATA(it))
  188.                      {
  189.                         if (it->Flags & CHECKED)
  190.                            gdd->gd_Active = 1;
  191.                         else
  192.                            gdd->gd_Active = 0;
  193.                         *update = TRUE;
  194.                      }
  195.                   }
  196.                }
  197.                else if (n_menu >= 2)
  198.                {
  199.                   struct Watch *w;
  200.  
  201.                   if (w = (struct Watch *)GTMENUITEM_USERDATA(it))
  202.                   {
  203.                      if (it->Flags & CHECKED)
  204.                         w->w_Flags |= WF_ACTIVE;
  205.                      else
  206.                         w->w_Flags &= ~WF_ACTIVE;
  207.                      *update = TRUE;
  208.                   }
  209.                }
  210.                code = it->NextSelect;
  211.             }
  212.          }
  213.          break;
  214.  
  215.          case IDCMP_GADGETUP:
  216.          break;
  217.       }
  218.    }
  219.  
  220.    return running;
  221. }
  222. /*E*/
  223.  
  224. /*F*/ PUBLIC BOOL preparemenu(GD gd)
  225. {
  226.    struct NewMenu *nm;
  227.    struct Watch *w;
  228.    ULONG i, ss;
  229.    BOOL rc = TRUE;
  230.    struct GlobalDevData *gdd;
  231.    WORD extraitems;
  232.  
  233.    /* calculate the number of additional menu items for display control */
  234.    extraitems = 0;
  235.  
  236.    /* device selection */
  237.    extraitems += gd->gd_NumDevices;
  238.  
  239.    SCANDEVS(gdd, &gd->gd_Devices)
  240.    {
  241.       /* Menu Title */
  242.       extraitems += 1;
  243.       /* Std. DeviceQuery+Stats */
  244.       extraitems += NUM_STDWATCHES;
  245.       /* SpecialStats */
  246.       extraitems += gdd->gd_ValidSpecialStats;
  247.       /* Type-Tracking */
  248.       extraitems += gdd->gd_NumTT * (NUM_TTWATCHES + 1);
  249.    }
  250.  
  251.    if (gd->gd_NewMenu = allocpvec(gd, sizeof(menu) + extraitems*sizeof(struct NewMenu)))
  252.    {
  253.       CopyMem((void*)menu, (void*)gd->gd_NewMenu, sizeof(menu));
  254.  
  255.       for (nm = gd->gd_NewMenu; nm->nm_Type != NM_END; ++nm)
  256.       {
  257.          STRPTR p;
  258.  
  259.          if ((nm->nm_Label != NM_BARLABEL) && !(menu->nm_Type & NM_IGNORE))
  260.          {
  261.             p = GetString(&gd->gd_LocaleInfo, (LONG)nm->nm_Label);
  262.             if (p[1] == '\0')
  263.             {
  264.                nm->nm_CommKey = p;
  265.                nm->nm_Label = p+2;
  266.             }
  267.             else
  268.                nm->nm_Label = p;
  269.          }
  270.       }
  271.  
  272.       gd->gd_DevSelStart = nm;
  273.  
  274.       SCANDEVS(gdd, &gd->gd_Devices)
  275.       {
  276.          nm->nm_Type = NM_ITEM;
  277.          nm->nm_UserData = (APTR)gdd;
  278.          nm->nm_Label = gdd->gd_Title;
  279.          nm->nm_Flags = CHECKIT|MENUTOGGLE;
  280.          nm->nm_CommKey = NULL;
  281.          ++nm;
  282.       }
  283.  
  284.       gd->gd_WatchStart = nm;
  285.  
  286.       SCANDEVS(gdd, &gd->gd_Devices)
  287.       {
  288.          /* Menu Title */
  289.          nm->nm_Type = NM_TITLE;
  290.          nm->nm_Label = gdd->gd_Title;
  291.          ++nm;
  292.  
  293.          /* Std. DeviceQuery+Stats */
  294.          for (i=0, w = gdd->gd_StdWatches; i<NUM_STDWATCHES; ++nm, ++i, ++w)
  295.          {
  296.             nm->nm_Type = NM_ITEM;
  297.             nm->nm_UserData = (APTR)w;
  298.             nm->nm_Label = w->w_Label;
  299.             nm->nm_Flags = CHECKIT|MENUTOGGLE;
  300.             nm->nm_CommKey = NULL;
  301.          }
  302.          /* SpecialStats */
  303.          for(ss = gdd->gd_ValidSpecialStats; ss; --ss, ++nm, ++w)
  304.          {
  305.             nm->nm_Type = NM_ITEM;
  306.             nm->nm_UserData = (APTR)w;
  307.             nm->nm_Label = w->w_Label;
  308.             nm->nm_Flags = CHECKIT|MENUTOGGLE;
  309.             nm->nm_CommKey = NULL;
  310.          }
  311.  
  312.          /* Type-Tracking */
  313.          for (w=gdd->gd_TrackWatches; w->w_Link.mln_Succ; w=(struct Watch*)w->w_Link.mln_Succ, ++nm)
  314.          {
  315.             if (w->w_Flags & WF_FIRSTTT)
  316.             {
  317.                nm->nm_Type = NM_ITEM;
  318.                nm->nm_Label = w->w_TrackType->tt_Label;
  319.                nm->nm_CommKey = NULL;
  320.                nm->nm_Flags = 0;
  321.                nm->nm_UserData = NULL;
  322.                ++nm;
  323.             }
  324.             nm->nm_Type = NM_SUB;
  325.             nm->nm_Label = w->w_Label;
  326.             nm->nm_CommKey = NULL;
  327.             nm->nm_Flags = CHECKIT|MENUTOGGLE;
  328.             nm->nm_UserData = (APTR)w;
  329.          }
  330.       }
  331.       nm->nm_Type = NM_END;
  332.    }
  333.    else rc = TRUE;
  334.  
  335.    return rc;
  336. }
  337. /*E*/
  338. /*F*/PUBLIC VOID checkmenu(GD gd)
  339. {
  340.    struct NewMenu *nm;
  341.    struct Watch *w;
  342.    struct GlobalDevData *gdd;
  343.    int i;
  344.  
  345.    for (i=0, nm = gd->gd_NewMenu + FIRST_REFRESH_ITEM; i<NUM_REFRESHS; ++nm, ++i)
  346.    {
  347.       if (intervals[i] == gd->gd_Refresh)
  348.          nm->nm_Flags |= CHECKED;
  349.       else
  350.          nm->nm_Flags &= ~CHECKED;
  351.    }
  352.  
  353.    for (i=gd->gd_NumDevices, nm = gd->gd_DevSelStart; i; ++nm, --i)
  354.    {
  355.       if (gdd = (struct GlobalDevData*)nm->nm_UserData)
  356.       {
  357.          if (gdd->gd_Active)
  358.             nm->nm_Flags |= CHECKED;
  359.          else
  360.             nm->nm_Flags &= ~CHECKED;
  361.       }
  362.    }
  363.  
  364.    for (nm = gd->gd_WatchStart; nm->nm_Type != NM_END; ++nm)
  365.    {
  366.       if (w = (struct Watch*)nm->nm_UserData)
  367.       {
  368.          if (w->w_Flags & WF_OFF)
  369.             nm->nm_Flags |= NM_ITEMDISABLED;
  370.  
  371.          if (w->w_Flags & WF_ACTIVE)
  372.             nm->nm_Flags |= CHECKED;
  373.          else
  374.             nm->nm_Flags &= ~CHECKED;
  375.       }
  376.    }
  377.    return ;
  378. }
  379. /*E*/
  380.  
  381. /*F*/ PUBLIC VOID updategui(GD gd, BOOL complete)
  382. {
  383.    struct GlobalDevData *gdd;
  384.    struct Watch *w;
  385.  
  386.    if (complete)
  387.    {
  388.       SCANDEVS(gdd, &gd->gd_Devices)
  389.       {
  390.          SCANWATCHES(w, &gdd->gd_Watches)
  391.          {
  392.             if (w->w_Flags & WF_ACTIVE)
  393.             {
  394.                LT_SetAttributes(gd->gd_Handle, w->w_ID,
  395.                                        GTNM_Number, *(w->w_Value),
  396.                                        TAG_DONE);
  397.             }
  398.          }
  399.       }
  400.    }
  401.    else
  402.    {
  403.       SCANDEVS(gdd, &gd->gd_Devices)
  404.       {
  405.          SCANWATCHES(w, &gdd->gd_Watches)
  406.          {
  407.             if ((w->w_Flags & (WF_ACTIVE | WF_STATIC)) == WF_ACTIVE)
  408.             {
  409.                LT_SetAttributes(gd->gd_Handle, w->w_ID,
  410.                                        GTNM_Number, *(w->w_Value),
  411.                                        TAG_DONE);
  412.             }
  413.          }
  414.       }
  415.    }
  416.    return ;
  417. }
  418. /*E*/
  419. /*F*/PUBLIC VOID closegui(GD gd)
  420. {
  421.    if (gd->gd_Handle)
  422.    {
  423.       gd->gd_Left = gd->gd_Handle->Window->LeftEdge;
  424.       gd->gd_Top = gd->gd_Handle->Window->TopEdge;
  425.  
  426.       LT_DeleteHandle(gd->gd_Handle);
  427.       gd->gd_Handle = NULL;
  428.    }
  429.    if (gd->gd_Menu)
  430.    {
  431.       LT_DisposeMenu(gd->gd_Menu);
  432.       gd->gd_Menu = NULL;
  433.    }
  434.    return ;
  435. }
  436. /*E*/
  437. /*F*/ PUBLIC BOOL opengui(GD gd)
  438. {
  439.    struct GlobalDevData *gdd;
  440.    struct PublicData *pd = gd->gd_Public;
  441.    BOOL rc = FALSE, vgroup;
  442.    int i;
  443.    struct Watch *w;
  444.    STRPTR windowtitle = "SANA2Meter";
  445.  
  446.    if (gd->gd_Handle = LT_CreateHandleTags(NULL,
  447.                                  LH_AutoActivate,FALSE,
  448.                                  LH_UserData, gd,
  449.                                  LAHN_MenuGlyphs, TRUE,
  450.                                  gd->gd_CustomFont ? LH_Font : TAG_IGNORE, &pd->pd_Font,
  451.                                  pd->pd_Pubscreen[0] ? LAHN_PubScreenName : TAG_IGNORE, pd->pd_Pubscreen,
  452.                                  TAG_DONE))
  453.    {
  454.       i = 0;
  455.       LT_New(gd->gd_Handle, LA_Type, HORIZONTAL_KIND, TAG_DONE);
  456.       if (gd->gd_NumActives == 0)
  457.       {
  458.          LT_New(gd->gd_Handle, LA_Type, TEXT_KIND,
  459.                         GTTX_Text, GetString(&gd->gd_LocaleInfo, TXT_INACTIVE),
  460.                         TAG_DONE);
  461.       }
  462.       else
  463.       {
  464.          SCANDEVS(gdd, &gd->gd_Devices)
  465.          {
  466.             if (gdd->gd_Active)
  467.             {
  468.                if (gd->gd_NumActives == 1) windowtitle = gdd->gd_Title;
  469.                vgroup = FALSE;
  470.                LT_New(gd->gd_Handle, LA_Type, VERTICAL_KIND,
  471.                                      (gd->gd_NumActives > 1) ?
  472.                                              LA_LabelText : TAG_IGNORE, gdd->gd_Title,
  473.                                      TAG_DONE);
  474.                SCANWATCHES(w, &gdd->gd_Watches)
  475.                {
  476.                   if ((w->w_Flags & WF_FIRSTTT) && (w->w_TrackType->tt_Flags & TTF_ACTIVE))
  477.                   {
  478.                      if (vgroup) {
  479.                         LT_EndGroup(gd->gd_Handle);
  480.                      }
  481.                      LT_New(gd->gd_Handle, LA_Type, VERTICAL_KIND, LA_LabelText, w->w_TrackType->tt_Label, TAG_DONE);
  482.                   }
  483.  
  484.                   if (w->w_Flags & WF_ACTIVE)
  485.                   {
  486.                      if (!vgroup)
  487.                      {
  488.                         vgroup = TRUE;
  489.                         LT_New(gd->gd_Handle, LA_Type, VERTICAL_KIND, TAG_DONE);
  490.                      }
  491.                      LT_New(gd->gd_Handle, LA_Type, NUMBER_KIND,
  492.                                            LA_LabelText, w->w_Label,
  493.                                            /*w->w_Format ? GTNM_Format : TAG_IGNORE, w->w_Format,*/
  494.                                            LA_ID, w->w_ID = ++i,
  495.                                            LA_NoKey, TRUE,
  496.                                            LA_Chars, 6,
  497.                                            w->w_Value ? GTNM_Number : TAG_IGNORE, *(w->w_Value),
  498.                                            LA_ExtraSpace, -1,
  499.                                            (GadToolsBase->lib_Version == 39) ?
  500.                                                 TAG_IGNORE : GTNM_Justification, GTJ_RIGHT,
  501.                                            TAG_DONE);
  502.                   }
  503.                }
  504.                if (vgroup) {
  505.                   LT_EndGroup(gd->gd_Handle);
  506.                }
  507.                LT_EndGroup(gd->gd_Handle);
  508.             }
  509.          }
  510.       }
  511.       LT_EndGroup(gd->gd_Handle);
  512.  
  513.       checkmenu(gd);
  514.       if (gd->gd_Menu = LT_NewMenuTemplate(gd->gd_Handle->Screen, NULL,
  515.                                            gd->gd_Handle->AmigaGlyph,
  516.                                            gd->gd_Handle->CheckGlyph,
  517.                                            NULL, gd->gd_NewMenu))
  518.       {
  519.          if (LT_Build(gd->gd_Handle, LAWN_Title,        windowtitle,
  520.                                      LAWN_IDCMP,        IDCMP_CLOSEWINDOW,
  521.                                      LAWN_SmartZoom,    TRUE,
  522.                                      LAWN_Menu,         gd->gd_Menu,
  523.                                      LAWN_Left,         gd->gd_Left,
  524.                                      LAWN_Top,          gd->gd_Top,
  525.                                      WA_Activate,       gd->gd_Inactive ? FALSE : TRUE,
  526.                                      WA_DepthGadget,    TRUE,
  527.                                      WA_DragBar,        TRUE,
  528.                                      WA_CloseGadget,    TRUE,
  529.                                      TAG_DONE))
  530.          {
  531.             ULONG pen = gd->gd_Handle->DrawInfo->dri_Pens[HIGHLIGHTTEXTPEN];
  532.  
  533.             if (gd->gd_ToBack)
  534.             {
  535.                WindowToBack(gd->gd_Handle->Window);
  536.                gd->gd_ToBack = 0;
  537.             }
  538.             gd->gd_Inactive = 0;
  539.  
  540.             if (gd->gd_NumActives != 0)
  541.             {
  542.                SCANDEVS(gdd, &gd->gd_Devices)
  543.                {
  544.                   SCANWATCHES(w, &gdd->gd_Watches)
  545.                   {
  546.                      if (w->w_Flags & WF_ACTIVE)
  547.                         LT_SetAttributes(gd->gd_Handle, w->w_ID, GTNM_FrontPen, pen, TAG_DONE);
  548.                   }
  549.                }
  550.             }
  551.             rc = TRUE;
  552.          }
  553.          else message(gd, REQ_ERROR_TITLE, REQ_ERROR_NOGUI, REQ_ERROR_QUITBUTTON);
  554.       }
  555.       else message(gd, REQ_ERROR_TITLE, REQ_ERROR_NOGUI, REQ_ERROR_QUITBUTTON);
  556.    }
  557.    else message(gd, REQ_ERROR_TITLE, REQ_ERROR_NOGUI, REQ_ERROR_QUITBUTTON);
  558.  
  559.    return rc;
  560. }
  561. /*E*/
  562.  
  563.